package handler

import (
	"admin-nexus-backend/internal/dto"
	"admin-nexus-backend/internal/model"
	"admin-nexus-backend/internal/service"
	"admin-nexus-backend/pkg/response"
	"encoding/json"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

type RoleHandler struct {
	roleService *service.RoleService
}

func NewRoleHandler(db *gorm.DB) *RoleHandler {
	return &RoleHandler{
		roleService: service.NewRoleService(db),
	}
}

// GetRoleList 获取角色列表
// @Summary 获取角色列表
// @Description 分页查询角色列表
// @Tags 角色管理
// @Security ApiKeyAuth
// @Produce json
// @Param page query int true "页码"
// @Param pageSize query int true "每页数量"
// @Param name query string false "角色名称"
// @Param code query string false "角色编码"
// @Param status query int false "状态"
// @Success 200 {object} response.Response{data=dto.PageResult}
// @Router /api/v1/roles [get]
func (h *RoleHandler) GetRoleList(c *gin.Context) {
	var params dto.RoleQueryParams
	if err := c.ShouldBindQuery(&params); err != nil {
		response.Error(c, "参数错误")
		return
	}

	result, err := h.roleService.GetRoleList(&params)
	if err != nil {
		response.Error(c, "获取角色列表失败")
		return
	}

	response.SuccessWithData(c, result)
}

// GetAllRoles 获取所有角色
// @Summary 获取所有角色
// @Description 获取所有启用的角色（不分页）
// @Tags 角色管理
// @Security ApiKeyAuth
// @Produce json
// @Success 200 {object} response.Response{data=[]model.Role}
// @Router /api/v1/roles/all [get]
func (h *RoleHandler) GetAllRoles(c *gin.Context) {
	roles, err := h.roleService.GetAllRoles()
	if err != nil {
		response.Error(c, "获取角色列表失败")
		return
	}

	response.SuccessWithData(c, roles)
}

// GetRoleByID 获取角色详情
// @Summary 获取角色详情
// @Description 根据角色ID获取角色详情
// @Tags 角色管理
// @Security ApiKeyAuth
// @Produce json
// @Param id path int true "角色ID"
// @Success 200 {object} response.Response{data=model.Role}
// @Router /api/v1/roles/{id} [get]
func (h *RoleHandler) GetRoleByID(c *gin.Context) {
	var req dto.IDRequest
	if err := c.ShouldBindUri(&req); err != nil {
		response.Error(c, "参数错误")
		return
	}

	role, err := h.roleService.GetRoleByID(req.ID)
	if err != nil {
		response.Error(c, "获取角色信息失败")
		return
	}

	response.SuccessWithData(c, role)
}

// CreateRole 创建角色
// @Summary 创建角色
// @Description 创建新角色
// @Tags 角色管理
// @Security ApiKeyAuth
// @Accept json
// @Produce json
// @Param req body dto.RoleCreateRequest true "角色信息"
// @Success 200 {object} response.Response
// @Router /api/v1/roles [post]
func (h *RoleHandler) CreateRole(c *gin.Context) {
	var req dto.RoleCreateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, "参数错误")
		return
	}

	if err := h.roleService.CreateRole(&req); err != nil {
		response.Error(c, err.Error())
		return
	}

	response.SuccessWithMessage(c, "创建角色成功")
}

// UpdateRole 更新角色
// @Summary 更新角色
// @Description 更新角色信息
// @Tags 角色管理
// @Security ApiKeyAuth
// @Accept json
// @Produce json
// @Param id path int true "角色ID"
// @Param req body dto.RoleUpdateRequest true "角色信息"
// @Success 200 {object} response.Response
// @Router /api/v1/roles/{id} [put]
func (h *RoleHandler) UpdateRole(c *gin.Context) {
	var uriReq dto.IDRequest
	if err := c.ShouldBindUri(&uriReq); err != nil {
		response.Error(c, "参数错误")
		return
	}

	var req dto.RoleUpdateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, "参数错误")
		return
	}

	if err := h.roleService.UpdateRole(uriReq.ID, &req); err != nil {
		response.Error(c, err.Error())
		return
	}

	response.SuccessWithData(c, nil)
}

// DeleteRole 删除角色
// @Summary 删除角色
// @Description 删除角色
// @Tags 角色管理
// @Security ApiKeyAuth
// @Produce json
// @Param id path int true "角色ID"
// @Success 200 {object} response.Response
// @Router /api/v1/roles/{id} [delete]
func (h *RoleHandler) DeleteRole(c *gin.Context) {
	var req dto.IDRequest
	if err := c.ShouldBindUri(&req); err != nil {
		response.Error(c, "参数错误")
		return
	}

	if err := h.roleService.DeleteRole(req.ID); err != nil {
		response.Error(c, err.Error())
		return
	}

	response.SuccessWithData(c, nil)
}

// AssignResources 分配资源
// @Summary 分配资源
// @Description 为角色分配资源权限
// @Tags 角色管理
// @Security ApiKeyAuth
// @Accept json
// @Produce json
// @Param id path int true "角色ID"
// @Param req body dto.RoleResourceRequest true "资源ID列表"
// @Success 200 {object} response.Response
// @Router /api/v1/roles/{id}/resources [put]
func (h *RoleHandler) AssignResources(c *gin.Context) {
	var uriReq dto.IDRequest
	if err := c.ShouldBindUri(&uriReq); err != nil {
		response.Error(c, "参数错误")
		return
	}

	var req dto.RoleResourceRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, "参数错误")
		return
	}

	if err := h.roleService.AssignResources(uriReq.ID, &req); err != nil {
		response.Error(c, err.Error())
		return
	}

	response.SuccessWithData(c, nil)
}

// GetRoleResources 获取角色资源
// @Summary 获取角色资源
// @Description 获取角色的资源ID列表
// @Tags 角色管理
// @Security ApiKeyAuth
// @Produce json
// @Param id path int true "角色ID"
// @Success 200 {object} response.Response{data=[]uint}
// @Router /api/v1/roles/{id}/resources [get]
func (h *RoleHandler) GetRoleResources(c *gin.Context) {
	var req dto.IDRequest
	if err := c.ShouldBindUri(&req); err != nil {
		response.Error(c, "参数错误")
		return
	}

	resourceIDs, err := h.roleService.GetRoleResources(req.ID)
	if err != nil {
		response.Error(c, "获取角色资源失败")
		return
	}

	response.SuccessWithData(c, resourceIDs)
}

// GetRoleDataPermission 获取角色数据权限
// @Summary 获取角色数据权限
// @Description 获取角色的数据权限配置
// @Tags 角色管理
// @Security ApiKeyAuth
// @Produce json
// @Param id path int true "角色ID"
// @Success 200 {object} response.Response{data=dto.RoleDataPermissionResponse}
// @Router /api/v1/data-permissions/role/{id} [get]
func (h *RoleHandler) GetRoleDataPermission(c *gin.Context) {
	var req dto.IDRequest
	if err := c.ShouldBindUri(&req); err != nil {
		response.Error(c, "参数错误")
		return
	}

	dataPermission, err := h.roleService.GetRoleDataPermission(req.ID)
	if err != nil {
		response.Error(c, "获取角色数据权限失败")
		return
	}

	// 解析 OrgIDs
	var orgIDs []uint
	if dataPermission.OrgIDs != "" {
		// 假设 OrgIDs 是 JSON 数组格式存储的
		_ = json.Unmarshal([]byte(dataPermission.OrgIDs), &orgIDs)
	}

	// 构建响应
	responseData := dto.RoleDataPermissionResponse{
		RoleID:        dataPermission.RoleID,
		DataScope:     int(dataPermission.DataScope),
		OrgIDs:        orgIDs,
		DataScopeText: getDataScopeText(int(dataPermission.DataScope)),
	}

	response.SuccessWithData(c, responseData)
}

// UpdateRoleDataPermission 更新角色数据权限
// @Summary 更新角色数据权限
// @Description 更新角色的数据权限配置
// @Tags 角色管理
// @Security ApiKeyAuth
// @Accept json
// @Produce json
// @Param id path int true "角色ID"
// @Param req body dto.RoleDataPermissionRequest true "数据权限配置"
// @Success 200 {object} response.Response
// @Router /api/v1/data-permissions/role/{id} [put]
func (h *RoleHandler) UpdateRoleDataPermission(c *gin.Context) {
	var uriReq dto.IDRequest
	if err := c.ShouldBindUri(&uriReq); err != nil {
		response.Error(c, "参数错误")
		return
	}

	var req dto.RoleDataPermissionRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, "参数错误")
		return
	}

	// 序列化 OrgIDs 为 JSON 字符串
	orgIDsJSON := ""
	if len(req.OrgIDs) > 0 {
		orgIDsBytes, _ := json.Marshal(req.OrgIDs)
		orgIDsJSON = string(orgIDsBytes)
	}

	// 构建数据权限对象
	dataPermission := &model.RoleDataPermission{
		DataScope: int8(req.DataScope),
		OrgIDs:    orgIDsJSON,
	}

	if err := h.roleService.UpdateRoleDataPermission(uriReq.ID, dataPermission); err != nil {
		response.Error(c, err.Error())
		return
	}

	response.SuccessWithMessage(c, "更新数据权限成功")
}

// getDataScopeText 获取数据范围文本描述
func getDataScopeText(dataScope int) string {
	switch dataScope {
	case 0:
		return "全部数据"
	case 1:
		return "本部门"
	case 2:
		return "本部门及以下"
	case 3:
		return "仅自己"
	case 4:
		return "自定义数据"
	default:
		return "未知权限"
	}
}
